﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Tools.TraceVisualiser.Components
{
	/// <summary>
	/// Knihovna obrázků v rozlišení 16 x 16 px, a případně menší
	/// </summary>
    public static class PicLibrary16
    {
        #region Image IcoMinus
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku IcoMinus.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu IcoMinus_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property IcoMinus, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property IcoMinus_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoMinus.png
        /// </remarks>
        public static System.Drawing.Image IcoMinus_Cached
        {
            get
            {
                if (_IcoMinus == null) _IcoMinus = IcoMinus;
                return _IcoMinus;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku IcoMinus.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image IcoMinus_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití IcoMinus_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property IcoMinus_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoMinus.png
        /// </remarks>
        public static System.Drawing.Image IcoMinus { get { return _ImageCreateFrom(_IcoMinus_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru IcoMinus.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití IcoMinus_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property IcoMinus_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoMinus.png
        /// </remarks>
        public static System.Drawing.Image IcoMinus_FromFile { get { return _ImageCreateFrom(_IcoMinus_string, "IcoMinus.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru IcoMinus
        /// </summary>
        /// <returns></returns>
        private static string _IcoMinus_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(276);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJCAYAAADgkQYQAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAP0lEQVQoU2PYtXvP/4kTJ+LEIHkGkIJfv3/jxCB5Kit6+/bNf+/k5RgYJA63DsTBheGKHj9+/B8XJl4RMeEEAIeDC6S7");
            sb.Append("CeqkAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property IcoMinus_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void IcoMinus_Reset()
        {
            _IcoMinus = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití IcoMinus_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _IcoMinus = null;
        #endregion
        #region Image IcoPlus
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku IcoPlus.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu IcoPlus_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property IcoPlus, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property IcoPlus_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoPlus.png
        /// </remarks>
        public static System.Drawing.Image IcoPlus_Cached
        {
            get
            {
                if (_IcoPlus == null) _IcoPlus = IcoPlus;
                return _IcoPlus;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku IcoPlus.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image IcoPlus_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití IcoPlus_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property IcoPlus_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoPlus.png
        /// </remarks>
        public static System.Drawing.Image IcoPlus { get { return _ImageCreateFrom(_IcoPlus_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru IcoPlus.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití IcoPlus_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property IcoPlus_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\IcoPlus.png
        /// </remarks>
        public static System.Drawing.Image IcoPlus_FromFile { get { return _ImageCreateFrom(_IcoPlus_string, "IcoPlus.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru IcoPlus
        /// </summary>
        /// <returns></returns>
        private static string _IcoPlus_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(320);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAJCAYAAADgkQYQAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAXklEQVQoU2PYtXvP/4kTJ+LEIHkGkII/f/7gxCB5DEWaTkUoGuCKfv3+/R+GQYqQ+SiKvJOX/0fHIMVwRW/fvvkPwyCT");
            sb.Append("kPlwRY8fP/4PwyBFyHysipAVgNhgRcSEEwC3dQRRe3jidwAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property IcoPlus_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void IcoPlus_Reset()
        {
            _IcoPlus = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití IcoPlus_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _IcoPlus = null;
        #endregion
        #region Image Dialogok4
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-4.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Dialogok4_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Dialogok4, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Dialogok4_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\dialog-ok-4.png
        /// </remarks>
        public static System.Drawing.Image Dialogok4_Cached
        {
            get
            {
                if (_Dialogok4 == null) _Dialogok4 = Dialogok4;
                return _Dialogok4;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku dialog-ok-4.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Dialogok4_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialogok4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialogok4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\dialog-ok-4.png
        /// </remarks>
        public static System.Drawing.Image Dialogok4 { get { return _ImageCreateFrom(_Dialogok4_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru dialog-ok-4.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dialogok4_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Dialogok4_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\dialog-ok-4.png
        /// </remarks>
        public static System.Drawing.Image Dialogok4_FromFile { get { return _ImageCreateFrom(_Dialogok4_string, "dialog-ok-4.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Dialogok4
        /// </summary>
        /// <returns></returns>
        private static string _Dialogok4_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1400);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAAG7AAABuwE67OPiAAAACXZwQWcAAAAQAAAAEABcxq3DAAAB");
            sb.Append("90lEQVQ4y2P8//8/AyWAiSLdpBrApWImyyVnXcQobMFHsgGcCvaKvAKq5xOy8nr5RMVOMYra8DIwMDCwEGuzkJj6yeTUSGE9A02Gn3/+qq9atGw9AwODC9wFXAo2OXJW");
            sb.Append("CV/5lVwmomiWtZIWEVI9HRbuIyouIczw8sUrBl4OZgYhIT4JuAu45ayy1QxsJ7m6GDNeOH8rj1/Z+f/Hu3sLeBTNJEQkFc+4ejqI8/NzMbx6+Yrh5Yu3DOvW7vjy8c2D");
            sb.Append("KLgB/CIy+Xq6CoyfP39hUFSUYPj+RTefX9mBjV9IItDCxlCCnZ2F4cXL1wy/f/5m2LF937cP7x46/Hp84hLcgE/vXm05f+5yoaqyHAMXDy+DqqY2w68frzMl5BQYBAUk");
            sb.Append("GH7//svw//d3hl27Dvx4/fyJ868nJ87CvMgIS0jc8nYLlDUU4pVUdBhY2bgY2NhYGBgZWBh+//rJ8O79U4Zrl87+ev/ym/O3p4ePYE0HXx8eSrh3697K27dOMfz7z8zA");
            sb.Append("yibIwM4lyPDr71eGyxeP/3n36qsHumaMdPDl/pGIR7eeb3x49yCDqIQoAxvHL4YTR7b+/fDql/f3J0f2Y43j////o2AGBgZGbnnzbWZBcf+lTez/sMtbeaOrQVGPVZCB");
            sb.Append("gZFL1iqLU8rGBp/m////IwKRXEBxbgQAG6f5I6TZnkUAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTVUMTc6MDI6MzQtMDc6MDC2544SAAAAJXRFWHRkYXRlOmNy");
            sb.Append("ZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwOToyNDozNi0wNzowMIXLx9cAAABndEVYdExpY2Vu");
            sb.Append("c2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnktc2EvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9MR1BMLzIu");
            sb.Append("MS9bjzxjAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA5LTAzLTE5VDEwOjUyOjUwLTA2OjAw2R/2sgAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAAAT");
            sb.Append("dEVYdFNvdXJjZQBPeHlnZW4gSWNvbnPsGK7oAAAAJ3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cub3h5Z2VuLWljb25zLm9yZy/vN6rLAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Dialogok4_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Dialogok4_Reset()
        {
            _Dialogok4 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Dialogok4_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Dialogok4 = null;
        #endregion
        #region Image Dial_OK
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Dial_OK.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Dial_OK_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Dial_OK, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Dial_OK_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\Dial_OK.png
        /// </remarks>
        public static System.Drawing.Image Dial_OK_Cached
        {
            get
            {
                if (_Dial_OK == null) _Dial_OK = Dial_OK;
                return _Dial_OK;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku Dial_OK.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Dial_OK_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dial_OK_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Dial_OK_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\Dial_OK.png
        /// </remarks>
        public static System.Drawing.Image Dial_OK { get { return _ImageCreateFrom(_Dial_OK_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru Dial_OK.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Dial_OK_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Dial_OK_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\Dial_OK.png
        /// </remarks>
        public static System.Drawing.Image Dial_OK_FromFile { get { return _ImageCreateFrom(_Dial_OK_string, "Dial_OK.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Dial_OK
        /// </summary>
        /// <returns></returns>
        private static string _Dial_OK_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(688);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAwAAAAQCAYAAAAiYZ4HAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAABdElEQVQ4T2NgGHjgzyDB4M2QxODJwE7YMb4MgrzpXKdTV4T+ZIhiKGbwY2DCrcmfgZU/naelZXfmn9UPp/13nWB+jyGa");
            sb.Append("QQGiwY/BTCCD7x5LMEslzATeeG7bsFnOX6af7/o//Wzn/7BpLq+FU4RUGBh8GITkiiW2Tjyc8d9/hvVboCYPhlAGEZ1K5de9R4v+dxyq+l+1LvovezTrFAZfBg4Gvgwe");
            sb.Append("lcjZtm8rt6f87zyY/N+ySeuUSLLQje7Dif9r96b/n3gw6z9/NM81oMelwLYzBTCJG5TLH6vfEfw/e0vg/9JNvv+bdgX9L9sf+r/zUPJ/vXzlH0Ana6N4lsmPyde1Rftd");
            sb.Append("1T6X/5k7zf9n7jH9n7LZ8H9Al94f7kCOUKwhA9TUHNar9z/5oOL/kANi/6u3WP8TDeKbDnQ3J86gFI3k2VC0wfT/tGuu/6X8hW8BFUvjjSwmDyZp/QzJiyrhor+BoadL");
            sb.Append("OGZBKnwZlIFYizjFtFAFAFtaf45sruglAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Dial_OK_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Dial_OK_Reset()
        {
            _Dial_OK = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Dial_OK_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Dial_OK = null;
        #endregion
        #region Image CndCN
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndCN.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndCN_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndCN, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndCN_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCN.png
        /// </remarks>
        public static System.Drawing.Image CndCN_Cached
        {
            get
            {
                if (_CndCN == null) _CndCN = CndCN;
                return _CndCN;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndCN.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndCN_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndCN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndCN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCN.png
        /// </remarks>
        public static System.Drawing.Image CndCN { get { return _ImageCreateFrom(_CndCN_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndCN.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndCN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndCN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCN.png
        /// </remarks>
        public static System.Drawing.Image CndCN_FromFile { get { return _ImageCreateFrom(_CndCN_string, "CndCN.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndCN
        /// </summary>
        /// <returns></returns>
        private static string _CndCN_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(284);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAARUlEQVQ4T2NgoAQYG6f9R8cg83CJwe0CKSDWYhS1ZGtEti0t7cx/bBiri5BtJKQRp1MHuUaqBA6h+KROPJKd5Ag5D5s8");
            sb.Append("AN+Bncn9d1O5AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndCN_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndCN_Reset()
        {
            _CndCN = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndCN_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndCN = null;
        #endregion
        #region Image CndCY
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndCY.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndCY_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndCY, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndCY_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCY.png
        /// </remarks>
        public static System.Drawing.Image CndCY_Cached
        {
            get
            {
                if (_CndCY == null) _CndCY = CndCY;
                return _CndCY;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndCY.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndCY_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndCY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndCY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCY.png
        /// </remarks>
        public static System.Drawing.Image CndCY { get { return _ImageCreateFrom(_CndCY_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndCY.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndCY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndCY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndCY.png
        /// </remarks>
        public static System.Drawing.Image CndCY_FromFile { get { return _ImageCreateFrom(_CndCY_string, "CndCY.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndCY
        /// </summary>
        /// <returns></returns>
        private static string _CndCY_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(272);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAO0lEQVQ4T2NgoAQYG6f9JwXD7QJpItZiFLVU0ZiWduY/NgxzEU4bRzUyMFA/OgglBAwbyUpyhGzBJg8A+DesIV6i7oYA");
            sb.Append("AAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndCY_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndCY_Reset()
        {
            _CndCY = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndCY_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndCY = null;
        #endregion
        #region Image CndEq
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndEq.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndEq_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndEq, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndEq_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndEq.png
        /// </remarks>
        public static System.Drawing.Image CndEq_Cached
        {
            get
            {
                if (_CndEq == null) _CndEq = CndEq;
                return _CndEq;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndEq.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndEq_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEq_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEq_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndEq.png
        /// </remarks>
        public static System.Drawing.Image CndEq { get { return _ImageCreateFrom(_CndEq_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndEq.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEq_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEq_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndEq.png
        /// </remarks>
        public static System.Drawing.Image CndEq_FromFile { get { return _ImageCreateFrom(_CndEq_string, "CndEq.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndEq
        /// </summary>
        /// <returns></returns>
        private static string _CndEq_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(236);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAIUlEQVQ4T2NgGAXEhYCxcdp/fJg4U0hRRX8bSXHdSFALANkPHLEylAJTAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndEq_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndEq_Reset()
        {
            _CndEq = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndEq_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndEq = null;
        #endregion
        #region Image CndGE
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndGE.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndGE_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndGE, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndGE_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGE.png
        /// </remarks>
        public static System.Drawing.Image CndGE_Cached
        {
            get
            {
                if (_CndGE == null) _CndGE = CndGE;
                return _CndGE;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndGE.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndGE_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndGE_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndGE_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGE.png
        /// </remarks>
        public static System.Drawing.Image CndGE { get { return _ImageCreateFrom(_CndGE_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndGE.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndGE_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndGE_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGE.png
        /// </remarks>
        public static System.Drawing.Image CndGE_FromFile { get { return _ImageCreateFrom(_CndGE_string, "CndGE.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndGE
        /// </summary>
        /// <returns></returns>
        private static string _CndGE_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(332);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAaUlEQVQ4T2NgGJrg/v3n/42N0/5XVs7+T7IP9uw5+z8oqBZsgKNjwf9Vq/aTbsjMmZv+W1pmgQ0BGUi0K0BOBzkbpBFk");
            sb.Append("CEGNyDalpHT/P3v2Fn5NsMABOY8svxF0EroCkF/wYZINHBwaAMGYTdvmOXfCAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndGE_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndGE_Reset()
        {
            _CndGE = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndGE_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndGE = null;
        #endregion
        #region Image CndGT
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndGT.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndGT_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndGT, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndGT_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGT.png
        /// </remarks>
        public static System.Drawing.Image CndGT_Cached
        {
            get
            {
                if (_CndGT == null) _CndGT = CndGT;
                return _CndGT;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndGT.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndGT_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndGT_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndGT_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGT.png
        /// </remarks>
        public static System.Drawing.Image CndGT { get { return _ImageCreateFrom(_CndGT_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndGT.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndGT_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndGT_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndGT.png
        /// </remarks>
        public static System.Drawing.Image CndGT_FromFile { get { return _ImageCreateFrom(_CndGT_string, "CndGT.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndGT
        /// </summary>
        /// <returns></returns>
        private static string _CndGT_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(324);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA0AAAAOCAYAAAD0f5bSAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAYUlEQVQoU2NgGObg/v3n/42N0/5XVs7+T5JX9+w5+z8oqBas2dGx4P+qVftJM2DmzE3/LS2zwAaADCPKdpBzQU4FaQIZ");
            sb.Append("gFcTsg0pKd3/z569hVsDLCBATiLZL0S5ffAqAgAhrj+DD5C2eAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndGT_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndGT_Reset()
        {
            _CndGT = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndGT_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndGT = null;
        #endregion
        #region Image CndLE
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndLE.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndLE_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndLE, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndLE_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLE.png
        /// </remarks>
        public static System.Drawing.Image CndLE_Cached
        {
            get
            {
                if (_CndLE == null) _CndLE = CndLE;
                return _CndLE;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndLE.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndLE_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLE_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLE_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLE.png
        /// </remarks>
        public static System.Drawing.Image CndLE { get { return _ImageCreateFrom(_CndLE_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndLE.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLE_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLE_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLE.png
        /// </remarks>
        public static System.Drawing.Image CndLE_FromFile { get { return _ImageCreateFrom(_CndLE_string, "CndLE.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndLE
        /// </summary>
        /// <returns></returns>
        private static string _CndLE_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(324);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAY0lEQVQ4T2NgGD5g5sxN/y0ts/6DaIK+2rPn7P+UlO7/xsZpYE2rVu0nrAmkGIQrK2cTVgxzwv37z8GagoJq/4NsJeg0");
            sb.Append("dAUg28iyGWYQyFaQ7SBDiAockp0Icx4ummQDB4cGAFLFRf09SdxEAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndLE_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndLE_Reset()
        {
            _CndLE = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndLE_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndLE = null;
        #endregion
        #region Image CndLT
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndLT.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndLT_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndLT, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndLT_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLT.png
        /// </remarks>
        public static System.Drawing.Image CndLT_Cached
        {
            get
            {
                if (_CndLT == null) _CndLT = CndLT;
                return _CndLT;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndLT.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndLT_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLT_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLT_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLT.png
        /// </remarks>
        public static System.Drawing.Image CndLT { get { return _ImageCreateFrom(_CndLT_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndLT.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLT_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLT_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndLT.png
        /// </remarks>
        public static System.Drawing.Image CndLT_FromFile { get { return _ImageCreateFrom(_CndLT_string, "CndLT.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndLT
        /// </summary>
        /// <returns></returns>
        private static string _CndLT_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(344);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAcklEQVQ4T2NgGOHg589f/2fO3PTf0jILTBMMjj17zv5PSen+b2ycBta0atX+/yBDcGr8+PELWDEIV1bO/g/iE7QFpOD+");
            sb.Append("/edgTUFBtf9BthKlCaYIZAvINrJshhkCshVkO8gQogIH3YmggCHavyT5jy6KAUwoVo/HjBNzAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndLT_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndLT_Reset()
        {
            _CndLT = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndLT_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndLT = null;
        #endregion
        #region Image CndQY
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndQY.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndQY_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndQY, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndQY_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndQY.png
        /// </remarks>
        public static System.Drawing.Image CndQY_Cached
        {
            get
            {
                if (_CndQY == null) _CndQY = CndQY;
                return _CndQY;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndQY.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndQY_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndQY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndQY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndQY.png
        /// </remarks>
        public static System.Drawing.Image CndQY { get { return _ImageCreateFrom(_CndQY_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndQY.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndQY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndQY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndQY.png
        /// </remarks>
        public static System.Drawing.Image CndQY_FromFile { get { return _ImageCreateFrom(_CndQY_string, "CndQY.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndQY
        /// </summary>
        /// <returns></returns>
        private static string _CndQY_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(256);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAMElEQVQ4T2NgGAU0CgFj47T/MIzLCqxq0AXT0s78BxmATBOlEZutxLiKRgEy9IwFANA+KAzcptb+AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndQY_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndQY_Reset()
        {
            _CndQY = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndQY_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndQY = null;
        #endregion
        #region Image CndSN
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndSN.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndSN_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndSN, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndSN_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSN.png
        /// </remarks>
        public static System.Drawing.Image CndSN_Cached
        {
            get
            {
                if (_CndSN == null) _CndSN = CndSN;
                return _CndSN;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndSN.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndSN_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndSN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndSN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSN.png
        /// </remarks>
        public static System.Drawing.Image CndSN { get { return _ImageCreateFrom(_CndSN_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndSN.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndSN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndSN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSN.png
        /// </remarks>
        public static System.Drawing.Image CndSN_FromFile { get { return _ImageCreateFrom(_CndSN_string, "CndSN.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndSN
        /// </summary>
        /// <returns></returns>
        private static string _CndSN_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(488);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAA3ElEQVQ4T2NgoATMnHnmPykYbpexcdp/ZIsfPfr6H4TRHQNSB7IAq0aQhrS0M//z88+jaARpwqtx5cpH/ysrL4E1nz//");
            sb.Append("HqwZpgnExmljU9PV/0ePvgFrnj//PtgWZK9g1fjmzU+wTSAaZHNy8jEUTTht3LPn5X+QjSAFzs5tKM6FBQhWG0Gapk6989/BoQGMQbaDnIscuhgaYc4EKUbG6KGLoRHk");
            sb.Append("THQ/gQIJZMjNm5/gtmJojIzc/D84eBlGpIM0ggIKpx9BfjIzy4EHPywabG0r/1taFqOIU5K8GQCI6P3vwrfIzAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndSN_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndSN_Reset()
        {
            _CndSN = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndSN_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndSN = null;
        #endregion
        #region Image CndSY
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndSY.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CndSY_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CndSY, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndSY_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSY.png
        /// </remarks>
        public static System.Drawing.Image CndSY_Cached
        {
            get
            {
                if (_CndSY == null) _CndSY = CndSY;
                return _CndSY;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku CndSY.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CndSY_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndSY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndSY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSY.png
        /// </remarks>
        public static System.Drawing.Image CndSY { get { return _ImageCreateFrom(_CndSY_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru CndSY.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndSY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CndSY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\CndSY.png
        /// </remarks>
        public static System.Drawing.Image CndSY_FromFile { get { return _ImageCreateFrom(_CndSY_string, "CndSY.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CndSY
        /// </summary>
        /// <returns></returns>
        private static string _CndSY_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(452);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAw0lEQVQ4T2NgoATMnHnmPykYbpexcdp/ZIsfPfr6H4SxOQZkAVaNIA1paWf+5+efJ03jypWP/ldWXgJrPn/+PYZmnDY2");
            sb.Append("NV39f/ToG7Dm+fPvE6fxzZufYJtANMhmbM7FauOePS//g2wEeR7kTGzOxaoRpGnq1Dv/b978BMYgjejOxdAIcyZIMTJGdy6GRpAz0RWBAglkCMh2WNxhaOzpuYk1FEEa");
            sb.Append("QQGFU6ODQ8N/M7Oc/6BUhIxtbSv/W1oWo4hRkrwZAOA49DSkSCo6AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CndSY_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CndSY_Reset()
        {
            _CndSY = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CndSY_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CndSY = null;
        #endregion
		#region Image CndEY
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndEY.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu CndEY_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property CndEY, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndEY_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEY.png
		/// </remarks>
		public static System.Drawing.Image CndEY_Cached
		{
			get
			{
				if (_CndEY == null) _CndEY = CndEY;
				return _CndEY;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndEY.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image CndEY_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEY_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEY_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEY.png
		/// </remarks>
		public static System.Drawing.Image CndEY { get { return _ImageCreateFrom(_CndEY_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru CndEY.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEY_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEY_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEY.png
		/// </remarks>
		public static System.Drawing.Image CndEY_FromFile { get { return _ImageCreateFrom(_CndEY_string, "CndEY.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru CndEY
		/// </summary>
		/// <returns></returns>
		private static string _CndEY_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(320);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAABGdBTUEAALGeYUxB9wAAACBjSFJNAAB6JQAAgIMAAPn/AACA6AAAUggAARVYAAA6lwAAF2/XWh+QAAAA");
			sb.Append("CXBIWXMAAA7BAAAOwQG4kWvtAAAAGXRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS44NzuAXQAAAD9JREFUOE9jYKAESEtb/CcFw+0CaSLW4vz8Rwi1FGk89+nv/3Of");
			sb.Append("/xPEGDYSowmkZkRqpG88goKYFEys67CqAwCkKjyZHxcwqgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property CndEY_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void CndEY_Reset()
		{
			_CndEY = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití CndEY_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _CndEY = null;
		#endregion
		#region Image CndEN
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndEN.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu CndEN_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property CndEN, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndEN_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEN.png
		/// </remarks>
		public static System.Drawing.Image CndEN_Cached
		{
			get
			{
				if (_CndEN == null) _CndEN = CndEN;
				return _CndEN;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndEN.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image CndEN_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEN_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEN_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEN.png
		/// </remarks>
		public static System.Drawing.Image CndEN { get { return _ImageCreateFrom(_CndEN_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru CndEN.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndEN_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndEN_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// L:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\CndEN.png
		/// </remarks>
		public static System.Drawing.Image CndEN_FromFile { get { return _ImageCreateFrom(_CndEN_string, "CndEN.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru CndEN
		/// </summary>
		/// <returns></returns>
		private static string _CndEN_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(524);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAABGdBTUEAALGeYUxB9wAAACBjSFJNAAB6JQAAgIMAAPn/AACA6AAAUggAARVYAAA6lwAAF2/XWh+QAAAA");
			sb.Append("CXBIWXMAAA7BAAAOwQG4kWvtAAAAGXRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS44NzuAXQAAANlJREFUOE9jYKAESEtb/CcFw+0CaSLW4vz8Rwi1FGk89+nv/3Of");
			sb.Append("//+ftW0/mIbhkOSM/8dff4fzMWwEKdx15/l/AWGR/52LVsEVSsop/N9y5T5+jVFZBf9BWNfUAq6Qk5vnv52n739jG4f/y4+e/49hI8g5INNBtqrpGoAVgVwhJiXzv7R7");
			sb.Append("EtgLDj4BmBrb5i//LyWvCDZZy9Dkv5NfEFgjyLDFB06BNaZV1mNqBGmYu/MwWMHUDTv/K6hpgDVycHL9FxQRAxtY2T8dUyN94xEUUqRgYl2HVR0A7nD+KmMI8KEAAAAA");
			sb.Append("SUVORK5CYII=");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property CndEN_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void CndEN_Reset()
		{
			_CndEN = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití CndEN_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _CndEN = null;
		#endregion
		#region Image CndLS
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndLS.png.
		/// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
		/// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
		/// Případně je možno vyvolat metodu CndLS_Reset(), která zajistí regenerování obrázku z jeho definice.
		/// Bezpečnější je používání property CndLS, která vrací vždy nový objekt.
		/// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CndLS_FromFile.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// c:\Documents and Settings\All Users\Data aplikací\IconLib\ComponentC16\CndLS.png
		/// </remarks>
		public static System.Drawing.Image CndLS_Cached
		{
			get
			{
				if (_CndLS == null) _CndLS = CndLS;
				return _CndLS;
			}
		}
		/// <summary>
		/// Vrátí obrázek, vytvořený na základě obrázku CndLS.png.
		/// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
		/// Pak je třeba použít Image CndLS_FromFile.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLS_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLS_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// c:\Documents and Settings\All Users\Data aplikací\IconLib\ComponentC16\CndLS.png
		/// </remarks>
		public static System.Drawing.Image CndLS { get { return _ImageCreateFrom(_CndLS_string, null); } }
		/// <summary>
		/// Vrátí obrázek, načtený ze souboru CndLS.png.
		/// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CndLS_Cached
		/// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
		/// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
		/// Pokud je třeba používat obrázek často a rychle, je možné využít property CndLS_Cached.
		/// </summary>
		/// <remarks>
		/// Plné jméno vstupního souboru:
		/// c:\Documents and Settings\All Users\Data aplikací\IconLib\ComponentC16\CndLS.png
		/// </remarks>
		public static System.Drawing.Image CndLS_FromFile { get { return _ImageCreateFrom(_CndLS_string, "CndLS.png"); } }
		/// <summary>
		/// Vygeneruje a vrátí string, který definuje obsah souboru CndLS
		/// </summary>
		/// <returns></returns>
		private static string _CndLS_string()
		{
			System.Text.StringBuilder sb = new System.Text.StringBuilder(356);
			sb.Append("iVBORw0KGgoAAAANSUhEUgAAAA4AAAAOCAYAAAAfSC3RAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
			sb.Append("OpgAABdwnLpRPAAAABl0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuODc7gF0AAABiSURBVDhPY2AYUCAubvCfGAx3JB8fXzYICwsr/i9KbcGJdy+5/T8+/tB/sEZp");
			sb.Append("aYv/xOCW8un/MTTe2v//Pz6cn//o/0jQ6O/fAQ5RlFAlJnCsrKyyURIZKMSIwQOaMsGWAwBKkkcJMlUGQgAAAABJRU5ErkJggg==");
			return sb.ToString();
		}
		/// <summary>
		/// Resetuje obrázek v paměti.
		/// Následující použití property CndLS_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
		/// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
		/// </summary>
		public static void CndLS_Reset()
		{
			_CndLS = null;
		}
		/// <summary>
		/// Úložiště objektu v paměti, při prvním použití CndLS_Direct je objekt naplněn a následně využíván.
		/// </summary>
		private static System.Drawing.Image _CndLS = null;
		#endregion
		#region Image ArwDn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku ArwDn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArwDn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArwDn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArwDn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwDn.png
        /// </remarks>
        public static System.Drawing.Image ArwDn_Cached
        {
            get
            {
                if (_ArwDn == null) _ArwDn = ArwDn;
                return _ArwDn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku ArwDn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArwDn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArwDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArwDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwDn.png
        /// </remarks>
        public static System.Drawing.Image ArwDn { get { return _ImageCreateFrom(_ArwDn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru ArwDn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArwDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArwDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwDn.png
        /// </remarks>
        public static System.Drawing.Image ArwDn_FromFile { get { return _ImageCreateFrom(_ArwDn_string, "ArwDn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArwDn
        /// </summary>
        /// <returns></returns>
        private static string _ArwDn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(248);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAMCAYAAACwXJejAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAKUlEQVQoU2NgoBX4DzQYhnHaQSdFyNags1Hchk0hVscT5XCQTpBCGgEAUrwb5Tl6s7cAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArwDn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArwDn_Reset()
        {
            _ArwDn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArwDn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArwDn = null;
        #endregion
        #region Image ArwUp
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku ArwUp.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu ArwUp_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property ArwUp, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property ArwUp_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwUp.png
        /// </remarks>
        public static System.Drawing.Image ArwUp_Cached
        {
            get
            {
                if (_ArwUp == null) _ArwUp = ArwUp;
                return _ArwUp;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku ArwUp.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image ArwUp_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArwUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArwUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwUp.png
        /// </remarks>
        public static System.Drawing.Image ArwUp { get { return _ImageCreateFrom(_ArwUp_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru ArwUp.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití ArwUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property ArwUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\ArwUp.png
        /// </remarks>
        public static System.Drawing.Image ArwUp_FromFile { get { return _ImageCreateFrom(_ArwUp_string, "ArwUp.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru ArwUp
        /// </summary>
        /// <returns></returns>
        private static string _ArwUp_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(248);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAMCAYAAACwXJejAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAKklEQVQoU2NgoCX4T8hwkAIYxqoWWQFWhdgU4DSRoHUgN9BZEaEgwi0PAL9BG+W2C1qwAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property ArwUp_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void ArwUp_Reset()
        {
            _ArwUp = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití ArwUp_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _ArwUp = null;
        #endregion
        #region Image Comments
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku insert-comments.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Comments_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Comments, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Comments_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image Comments_Cached
        {
            get
            {
                if (_Comments == null) _Comments = Comments;
                return _Comments;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku insert-comments.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Comments_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Comments_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Comments_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image Comments { get { return _ImageCreateFrom(_Comments_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru insert-comments.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Comments_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Comments_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\insert-comments.png
        /// </remarks>
        public static System.Drawing.Image Comments_FromFile { get { return _ImageCreateFrom(_Comments_string, "insert-comments.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Comments
        /// </summary>
        /// <returns></returns>
        private static string _Comments_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1436);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAfFJREFUOMuNkk1rE1EUhp+ZJkOtk1pqqStBLVEXdSG0bly5GlBcCok/oKAgbseNukvwHyilkWwCZilCklJdJEgFCRRqSkiJ2NLiV1OKxiTz");
            sb.Append("cY+bpCVhUvrC5cK95z3nvQ9XiyVyV4EFYIZgtYECsJyxra3ByxDwYOH27OxcdBrpncrR1nE9s7S+ez9b3DwPPB9soAMX56LT+AK+As8HRwmOL3Q8hREOMX/5HMCloHih");
            sb.Append("3iQR8JQgIoiAEkEJgOI4hQBN00AJSNdU3W6Mv12tz/w6aEW0oxepeDJ/t+trAmkgHQI6jqPGImNhGk2FiPDu09fonRsXzgRwMbpcJkrru0+yxc0rOpB7vVzhy7c9zpph");
            sb.Append("piIG3/ebp0/I5Zqesa3Fz7Wfz15ky3v7fzt8WNvB9VQfF08pfF9wfYXrC453xEUHyNhWCWit1X+TKlRcoD3IpQdVKUEpYUTXAMI6QDyZPwVMLuUrDvAIaDqOwhwd6WsS");
            sb.Append("0jVGwzqTpoHrK4CO3k1iAmXgYca2akAqvbJBdbtxyGUqYuC6Hn/+dXhTrGEvfWwBrzSRQ859iifz94DFl49vja9u/CBVqAhQB1rAe+BpxrYOuh8neMUSuWqhvCWxRK4d");
            sb.Append("S+SuB9Ucl8AEdgADuJmxrXJQnc5wTQArwPwwMzA8wUn1H+DSNPT2LId8AAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0");
            sb.Append("RVh0ZGF0ZTpjcmVhdGUAMjAxMC0wMS0xMVQwNjo1MzowMC0wNzowMPVeln0AAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTM6MDAtMDc6MDCEAy7BAAAA");
            sb.Append("YnRFWHRMaWNlbnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMv");
            sb.Append("YnkvMi41L4uGPGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NTE6MTAtMDc6MDApaOuNAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccll");
            sb.Append("PAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3Np");
            sb.Append("bGsvwsQNDQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Comments_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Comments_Reset()
        {
            _Comments = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Comments_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Comments = null;
        #endregion
        #region Image DbConnect
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku database-connect.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu DbConnect_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property DbConnect, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property DbConnect_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\database-connect.png
        /// </remarks>
        public static System.Drawing.Image DbConnect_Cached
        {
            get
            {
                if (_DbConnect == null) _DbConnect = DbConnect;
                return _DbConnect;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku database-connect.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image DbConnect_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DbConnect_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DbConnect_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\database-connect.png
        /// </remarks>
        public static System.Drawing.Image DbConnect { get { return _ImageCreateFrom(_DbConnect_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru database-connect.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití DbConnect_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property DbConnect_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\database-connect.png
        /// </remarks>
        public static System.Drawing.Image DbConnect_FromFile { get { return _ImageCreateFrom(_DbConnect_string, "database-connect.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru DbConnect
        /// </summary>
        /// <returns></returns>
        private static string _DbConnect_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1672);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAqNJREFUOMulks1LVGEUh3937sfkjNZYTHozCRptrIEkWoSrhDa5mWxXy+gPaOHK/oZcuhHaFNQiqJaZc4mgAonAYIqSUJyUrKmbM3fu1/ue");
            sb.Append("9z0tIu0LWnSW58BznvPjGMyM/ynrb03P87LMXGXmi1rrEWYeZmatta4z8zut9XWttTc5OamM3w08zzvGzLeLxeLx/v5+5PN55HI5MDNarRaCIECj0UCz2XzCzBf+ACws");
            sb.Append("LDwql8vjg4ODMAzjr9pEhHq9juXl5RuZ34fMXOnr6/vn7QMDA9BaT/yRgWQ7s7i4iDAMMTY2hmw2C9u2wcyIogi+72NjYwOlUgla650Qbz3xu4RUtyjes9fkT3AcB7Va");
            sb.Append("DZVKBcwMIkK73UaaprAsC8y8A7jx+IslpXyZtY1hq9CPV6sfcbjQhlIK+XwelmWBiEBE+JGZ1hpKKWQAIE7EgTil4ZwDmIaGuXcYz9aycEsnMD8/j9nZWUgpQUSQUkIp");
            sb.Append("tW2QAYBOJAZSIRAnAu+bIWxTwykcwNy950jTFKOjo5iZmYEQYhvEzDsGQRwXo0QgTAQ6UYLVD23ssgH3UAlP30ZYWVmB67pQSv0CkFJ+B7SC+IiQKaJEoh2lCMIEy+s+");
            sb.Append("toIUXQdP4sELjeq589tbiQhaawghYDb3V50gSr1iwTHbYQLHNGCZgJUxoLRCY7WJibEhHD1cQBRF6O3txcjICBqNBtbW1iJrK4g7u3MZWxEhjFO832gh+Boi7iRIOimG");
            sb.Append("3DwuXzgFxzbhui6CIEC9XsfS0tImEVWtrU7kZdg++/pzgPV1X8owudrXo1unyqju222c3tMterzaQxARfN9HkiSbRHRTKXVtenr6kzF+5X4XxfIuxekZikX38zuXxM+f");
            sb.Append("OTc310NEQ0SkpZRvpqam0p/n3wC8rrdXsoPNawAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNy0wNzowMFsA/sEAAAAldEVYdGRhdGU6Y3JlYXRl");
            sb.Append("ADIwMTAtMDEtMTFUMDY6NTM6MDYtMDc6MDCWjqNHAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUzOjA2LTA3OjAw59Mb+wAAAGJ0RVh0TGljZW5zZQBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAA");
            sb.Append("JXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIxOjUxOjU2LTA3OjAwzvLQTQAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJj");
            sb.Append("ZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAzdEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVO");
            sb.Append("RK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property DbConnect_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void DbConnect_Reset()
        {
            _DbConnect = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití DbConnect_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _DbConnect = null;
        #endregion
        #region Image Identity
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku identity.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Identity_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Identity, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Identity_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\identity.png
        /// </remarks>
        public static System.Drawing.Image Identity_Cached
        {
            get
            {
                if (_Identity == null) _Identity = Identity;
                return _Identity;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku identity.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Identity_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Identity_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Identity_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\identity.png
        /// </remarks>
        public static System.Drawing.Image Identity { get { return _ImageCreateFrom(_Identity_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru identity.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Identity_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Identity_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\David\_Cs2010\TraceVisualiser\TraceVisualiser\Pics\Pic16\identity.png
        /// </remarks>
        public static System.Drawing.Image Identity_FromFile { get { return _ImageCreateFrom(_Identity_string, "identity.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Identity
        /// </summary>
        /// <returns></returns>
        private static string _Identity_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(5068);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGOfPtRkwAACj1pQ0NQaWNjAAB42p1TZ1RT6RY99970QkuIgJRLb1IVCCBSQouAVGmiEpIA");
            sb.Append("oYQYEkDsiKjAiKIighUZFHHA0RGQsSKKhUGx9wF5CCjj4Cg2VN4P3hp9s+a9N2/2r732OWed75x9PgBGYLBEmoWqAWRKFfKIAB88Ni4eJ3cDClQggQOAQJgtC4n0jwIA");
            sb.Append("4Pvx8OyIAB/4AgTgzW1AAABu2ASG4Tj8f1AXyuQKACQMAKaLxNlCAKQQADJyFTIFADIKAOykdJkCACUAAFseGxcPgGoBADtlkk8DAHbSJPcCALYoUyoCQKMAQCbKFIkA");
            sb.Append("0A4AWJejFIsAsGAAKMqRiHMBsJsAYJKhzJQAYO8AgJ0pFmQDEBgAYKIQC1MBCPYAwJBHRfAACDMBKIyUr3jSV1whzlMAAPCyZIvlkpRUBW4htMQdXF25eKA4N0OsUNiE");
            sb.Append("CYTpArkI52VlygTSxQCTMwMAgEZ2RIAPzvfjOTu4OjvbONo6fLWo/xr8i4iNi/+XP6/CAQEAhNP1RfuzvKwaAO4YALbxi5a0HaBlDYDW/S+ayR4A1UKA5qtfzcPh+/Hw");
            sb.Append("VIVC5mZnl5ubaysRC22FqV/1+Z8JfwFf9bPl+/Hw39eD+4qTBcoMBR4R4IMLszKylHI8WyYQinGbPx7x3y7883dMixAni+ViqVCMR0vEuRJpCs7LkookCkmWFJdI/5OJ");
            sb.Append("f7PsD5i8awBg1X4G9kJbULvKBuyXLiCw6IAl7AIA5HffgqnREAYAMQaDk3cPADD5m/8daBkAoNmSFBwAgBcRhQuV8pzJGAEAgAg0UAU2aIM+GIMF2IAjuIA7eIEfzIZQ");
            sb.Append("iII4WABCSIVMkEMuLIVVUAQlsBG2QhXshlqoh0Y4Ai1wAs7CBbgC1+AWPIBeGIDnMApvYBxBEDLCRFiINmKAmCLWiCPCRWYhfkgwEoHEIYlICiJFlMhSZDVSgpQjVche");
            sb.Append("pB75HjmOnEUuIT3IPaQPGUZ+Qz6gGMpA2ageaobaoVzUGw1Co9D5aAq6CM1HC9ENaCVagx5Cm9Gz6BX0FtqLPkfHMMDoGAczxGwwLsbDQrF4LBmTY8uxYqwCq8EasTas");
            sb.Append("E7uB9WIj2HsCicAi4AQbgjshkDCXICQsIiwnlBKqCAcIzYQOwg1CH2GU8JnIJOoSrYluRD4xlphCzCUWESuIdcRjxPPEW8QB4hsSicQhmZNcSIGkOFIaaQmplLST1EQ6");
            sb.Append("Q+oh9ZPGyGSyNtma7EEOJQvICnIReTv5EPk0+Tp5gPyOQqcYUBwp/pR4ipRSQKmgHKScolynDFLGqWpUU6obNZQqoi6mllFrqW3Uq9QB6jhNnWZO86BF0dJoq2iVtEba");
            sb.Append("edpD2is6nW5Ed6WH0yX0lfRK+mH6RXof/T1Dg2HF4DESGErGBsZ+xhnGPcYrJpNpxvRixjMVzA3MeuY55mPmOxWWiq0KX0WkskKlWqVZ5brKC1Wqqqmqt+oC1XzVCtWj");
            sb.Append("qldVR9SoamZqPDWB2nK1arXjanfUxtRZ6g7qoeqZ6qXqB9UvqQ9pkDXMNPw0RBqFGvs0zmn0szCWMYvHErJWs2pZ51kDbBLbnM1np7FL2N+xu9mjmhqaMzSjNfM0qzVP");
            sb.Append("avZyMI4Zh8/J4JRxjnBucz5M0ZviPUU8Zf2UxinXp7zVmqrlpSXWKtZq0rql9UEb1/bTTtfepN2i/UiHoGOlE66Tq7NL57zOyFT2VPepwqnFU49Mva+L6lrpRugu0d2n");
            sb.Append("26U7pqevF6An09uud05vRJ+j76Wfpr9F/5T+sAHLYJaBxGCLwWmDZ7gm7o1n4JV4Bz5qqGsYaKg03GvYbThuZG4016jAqMnokTHNmGucbLzFuN141MTAJMRkqUmDyX1T");
            sb.Append("qinXNNV0m2mn6Vszc7MYs7VmLWZD5lrmfPN88wbzhxZMC0+LRRY1FjctSZZcy3TLnZbXrFArJ6tUq2qrq9aotbO1xHqndc804jTXadJpNdPu2DBsvG1ybBps+mw5tsG2");
            sb.Append("BbYtti/sTOzi7TbZddp9tneyz7CvtX/goOEw26HAoc3hN0crR6FjtePN6czp/tNXTG+d/nKG9QzxjF0z7jqxnEKc1jq1O31ydnGWOzc6D7uYuCS67HC5w2Vzw7il3Iuu");
            sb.Append("RFcf1xWuJ1zfuzm7KdyOuP3qbuOe7n7QfWim+UzxzNqZ/R5GHgKPvR69s/BZibP2zOr1NPQUeNZ4PvEy9hJ51XkNelt6p3kf8n7hY+8j9znm85bnxlvGO+OL+Qb4Fvt2");
            sb.Append("+2n4zfWr8nvsb+Sf4t/gPxrgFLAk4EwgMTAocFPgHb4eX8iv54/Odpm9bHZHECMoMqgq6EmwVbA8uC0EDZkdsjnk4RzTOdI5LaEQyg/dHPoozDxsUdiP4aTwsPDq8KcR");
            sb.Append("DhFLIzojWZELIw9GvonyiSqLejDXYq5ybnu0anRCdH302xjfmPKY3li72GWxV+J04iRxrfHk+Oj4uvixeX7zts4bSHBKKEq4Pd98ft78Swt0FmQsOLlQdaFg4dFEYmJM");
            sb.Append("4sHEj4JQQY1gLImftCNpVMgTbhM+F3mJtoiGxR7icvFgskdyefJQikfK5pThVM/UitQRCU9SJXmZFpi2O+1temj6/vSJjJiMpkxKZmLmcamGNF3akaWflZfVI7OWFcl6");
            sb.Append("F7kt2rpoVB4kr8tGsudntyrYCpmiS2mhXKPsy5mVU53zLjc692ieep40r2ux1eL1iwfz/fO/XUJYIlzSvtRw6aqlfcu8l+1djixPWt6+wnhF4YqBlQErD6yirUpf9VOB");
            sb.Append("fUF5wevVMavbCvUKVxb2rwlY01CkUiQvurPWfe3udYR1knXd66ev377+c7Go+HKJfUlFycdSYenlbxy+qfxmYkPyhu4y57JdG0kbpRtvb/LcdKBcvTy/vH9zyObmLfiW");
            sb.Append("4i2vty7ceqliRsXubbRtym29lcGVrdtNtm/c/rEqtepWtU910w7dHet3vN0p2nl9l9euxt16u0t2f9gj2XN3b8De5hqzmop9pH05+57WRtd2fsv9tr5Op66k7tN+6f7e");
            sb.Append("AxEHOupd6usP6h4sa0AblA3DhxIOXfvO97vWRpvGvU2cppLDcFh5+Nn3id/fPhJ0pP0o92jjD6Y/7DjGOlbcjDQvbh5tSW3pbY1r7Tk++3h7m3vbsR9tf9x/wvBE9UnN");
            sb.Append("k2WnaKcKT02czj89dkZ2ZuRsytn+9oXtD87FnrvZEd7RfT7o/MUL/hfOdXp3nr7ocfHEJbdLxy9zL7dccb7S3OXUdewnp5+OdTt3N191udp6zfVaW8/MnlPXPa+fveF7");
            sb.Append("48JN/s0rt+bc6rk99/bdOwl3eu+K7g7dy7j38n7O/fEHKx8SHxY/UntU8Vj3cc3Plj839Tr3nuzz7et6EvnkQb+w//k/sv/xcaDwKfNpxaDBYP2Q49CJYf/ha8/mPRt4");
            sb.Append("Lns+PlL0i/ovO15YvPjhV69fu0ZjRwdeyl9O/Fb6SvvV/tczXrePhY09fpP5Zvxt8Tvtdwfec993foj5MDie+5H8sfKT5ae2z0GfH05kTkz8EwOY8/wlYzOiAAAAIGNI");
            sb.Append("Uk0AAHolAACAgwAA+f8AAIDpAAB1MAAA6mAAADqYAAAXb5JfxUYAAAAGYktHRAAAAAAAAPlDu38AAAAJcEhZcwAACxMAAAsTAQCanBgAAAAJdnBBZwAAABAAAAAQAFzG");
            sb.Append("rcMAAAKFSURBVDjLjZK9TxNxHMafe7+2d9deW6AnfYEqgcQoqIjBGI0hJg6uTi4upoNMxJgY46AhDgw6ok7+AyYuLhqNsLiYYAhiEEtLacNLKVzL0fZefw5GItBEnvmT");
            sb.Append("J8/3ky9FCMHBKOEMp3V3PvbJyq1SdpnjBP5NvVq7r5cnGwdZGi0SjmuP7j25/WBoZDDpEWgBNTgaiWsTrVjq4AIlnKESfT2/1GNt6eLCErZKqxBlBVJbbL26qacq+XHz");
            sb.Append("X549NImh2fLKmrD8YwE0AE6OggmlYAlRfyAlCgD2FRw6QS9P2rbVzDM0DdanwNfRi0DiLJTuc6uFqRu1IzlgeXZKCofAyVFwoSQkLY5YWvnaim1Z4JjWa7kt0hAVFeAl");
            sb.Append("+BQBPtF5dSSJfxOJ3f3kjx2/GkwPwzOK3+bf3zxz5AVqx2gXI3VoLCeA3c1DLywGlXCm978LJDVzheO5MSYQuS6nBvhgogsAQbWQg1Gcd7xm7aNr7T6D537QN1+SfQWn");
            sb.Append("Lz4dPz8y/PDd21mA5sH6VfjUdlA0jYZeARwTjlWDZxpwqhvPK8WJsb0COXQnkh66MJM81Z/I5XbAiBI8iHA8Bp4HEJfAs224lgHPMmBv5fL10uwlvfyixAIAHwjG1it8");
            sb.Append("O1ZNDFwbQNOksGMAhAJAAMciMOsOGjs26ttV0KygNTcWUwBKNACYZu0E75MFx2zChQDb9sBxLkTOhci7CEge1CiNWJcfrpEHsU3BpaiTe6/c0JcXaoUv000jNZiN9fhV");
            sb.Append("LQyaoeDhjx8CCoRQ0Ne2oa/8rFuV3Ex9K/d9n0SKuswCdJKXO4fD3X39Uns8yfkVlWYYyjEbtd3N9eJmdm6uWcl+BtwlQqY9APgNYEcSqghJx4gAAAAldEVYdGNyZWF0");
            sb.Append("ZS1kYXRlADIwMDktMTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA4OjQyOjQwLTA3OjAwpb4gyQAAACV0RVh0ZGF0");
            sb.Append("ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo0Mjo0MC0wNzowMNTjmHUAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8y");
            sb.Append("LjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMToyNy0wNzowMIHbSjQAAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RF");
            sb.Append("WHRTb3VyY2VfVVJMAGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Identity_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Identity_Reset()
        {
            _Identity = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Identity_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Identity = null;
        #endregion
        #region Image SrtDn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku SrtDn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu SrtDn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property SrtDn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property SrtDn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtDn.png
        /// </remarks>
        public static System.Drawing.Image SrtDn_Cached
        {
            get
            {
                if (_SrtDn == null) _SrtDn = SrtDn;
                return _SrtDn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku SrtDn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image SrtDn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití SrtDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property SrtDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtDn.png
        /// </remarks>
        public static System.Drawing.Image SrtDn { get { return _ImageCreateFrom(_SrtDn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru SrtDn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití SrtDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property SrtDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtDn.png
        /// </remarks>
        public static System.Drawing.Image SrtDn_FromFile { get { return _ImageCreateFrom(_SrtDn_string, "SrtDn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru SrtDn
        /// </summary>
        /// <returns></returns>
        private static string _SrtDn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(368);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAMCAYAAACwXJejAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAg0lEQVQoU2NgGNbAJq7of3DTvP+ZC/f/L1h5/H/xmtP/G3dc/99/6O7/6cce/N9+7cV/cACUL9z5P2X+gf9VW4GSxx7/");
            sb.Append("X3T+5f8N19/8P/X4A0QBDHTtvPK/eufd/4uufvi/4+4nTAUwhdNPPP6//Nr7/+dffEU1AT3AF5+HuoHUmAAAtChOjaUjfiwAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property SrtDn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void SrtDn_Reset()
        {
            _SrtDn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití SrtDn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _SrtDn = null;
        #endregion
        #region Image SrtUp
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku SrtUp.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu SrtUp_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property SrtUp, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property SrtUp_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtUp.png
        /// </remarks>
        public static System.Drawing.Image SrtUp_Cached
        {
            get
            {
                if (_SrtUp == null) _SrtUp = SrtUp;
                return _SrtUp;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku SrtUp.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image SrtUp_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití SrtUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property SrtUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtUp.png
        /// </remarks>
        public static System.Drawing.Image SrtUp { get { return _ImageCreateFrom(_SrtUp_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru SrtUp.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití SrtUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property SrtUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\SrtUp.png
        /// </remarks>
        public static System.Drawing.Image SrtUp_FromFile { get { return _ImageCreateFrom(_SrtUp_string, "SrtUp.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru SrtUp
        /// </summary>
        /// <returns></returns>
        private static string _SrtUp_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(364);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAAAkAAAAMCAYAAACwXJejAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjbQg61aAAAAf0lEQVQoU2NgIAcsPv/iP1590088/r/82vv/5198xa6wa+eV/9U77/5fdPXD/x13P/0/9fgDqsLyhTv/p8w/8L9q6/X/");
            sb.Append("/cce/190/uX/DdffIBTaxBX9D26a9z9z4f7/BSuP/y9ec/p/4w6g4kN3/08/9uD/9msE3EiOxweVHgD3AE6NTFcEfwAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property SrtUp_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void SrtUp_Reset()
        {
            _SrtUp = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití SrtUp_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _SrtUp = null;
        #endregion
        #region Image GoDn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GoDn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoDn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoDn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoDn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoDn.png
        /// </remarks>
        public static System.Drawing.Image GoDn_Cached
        {
            get
            {
                if (_GoDn == null) _GoDn = GoDn;
                return _GoDn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GoDn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoDn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoDn.png
        /// </remarks>
        public static System.Drawing.Image GoDn { get { return _ImageCreateFrom(_GoDn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru GoDn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoDn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoDn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoDn.png
        /// </remarks>
        public static System.Drawing.Image GoDn_FromFile { get { return _ImageCreateFrom(_GoDn_string, "GoDn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoDn
        /// </summary>
        /// <returns></returns>
        private static string _GoDn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(708);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAAboAAAG6AeirAQYAAAATdEVYdFNvdXJj");
            sb.Append("ZQBPeHlnZW4gSWNvbnPsGK7oAAAAGXRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS420IOtWgAAAWJJREFUOE9jYBg2gJEhgIGTJMzAwIjwvS9Dq1eL13/XVtf/Vq1W");
            sb.Append("/3U7dP8rdSv9F+8X/88wgfE/wzwgXsn0n2E103+xVRL/VRdr/GfoZZ6FMMCJQciowOht88Hmf9mbsv8HLQ/6b7XI6r/qEtX/DIsZ/jPsAOIzQHyB4T/rDtZ/YjOkPjO0");
            sb.Append("M0iihr8Hg5Fjo+PPgm0F/8NXhv+3W2z3X2uR1n+GuUCN64B4FwRLLJT+zdDM4oI98vwYEn0n+P6JXhn933mB83/dubr/mSYCnQ4yZCnDf9EF4n+Y6tnK8cY8axDrDL/p");
            sb.Append("fn/c57j/15+i/5+tie0/QxfDf95JfL85G3nWEU42DQyMvLG8p90muf0x6TH5z1rA+p+9iv03dz3vDQagHGEDQCqAgSqaLvbaosniH0ssyz+eMr4PDHkMEsRphqkKZDCR");
            sb.Append("zZL7yZ3E84shlcWONM0w1REMwQyJzBHkaR4yugB2kX8yuDSU8gAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoDn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoDn_Reset()
        {
            _GoDn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoDn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoDn = null;
        #endregion
        #region Image GoUp
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GoUp.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu GoUp_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property GoUp, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property GoUp_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoUp.png
        /// </remarks>
        public static System.Drawing.Image GoUp_Cached
        {
            get
            {
                if (_GoUp == null) _GoUp = GoUp;
                return _GoUp;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku GoUp.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image GoUp_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoUp.png
        /// </remarks>
        public static System.Drawing.Image GoUp { get { return _ImageCreateFrom(_GoUp_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru GoUp.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití GoUp_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property GoUp_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\GoUp.png
        /// </remarks>
        public static System.Drawing.Image GoUp_FromFile { get { return _ImageCreateFrom(_GoUp_string, "GoUp.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru GoUp
        /// </summary>
        /// <returns></returns>
        private static string _GoUp_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(700);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAAboAAAG6AeirAQYAAAATdEVYdFNvdXJj");
            sb.Append("ZQBPeHlnZW4gSWNvbnPsGK7oAAAAGXRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS420IOtWgAAAV5JREFUOE9jYBjmIIIh2KDeOIU8XwYymMgmy/2USpP+xZDKYkea");
            sb.Append("IU4MQqJJYq8tyiz+sXiw/OMp5PvAkMcgQZwhDQyMvFG8p9063f6Y1Jv8Z41l/c+ezv6bu5b3BgNQjqAhrEGsM/wm+f1xn+L+X79d/z9bIdt/hlKG/7yNfL85G3nW4TfA");
            sb.Append("jyHRt8f3T/SS6P/OM53/607W/c/UwPSfoYvhP0M/w3/RqeJ/mOrZyrEb4sFg5Njg+LNgc8H/8KXh/+3m2v3XmqX1n2ECUPNcIF4KxEuAuI/5N0MziwuqIcBAMyowett8");
            sb.Append("oPlf9sbs/0FLg/5bzbf6rzpfFaJ5HRDvBuJdDP9Z17D+E5sm9ZmhnUESYYgvQ6tXi9d/11bX/1atVv91O3X/q/aq/peZLPOfcxrXf54lvP/5Nwj+F94i+l9stcR/9SWa");
            sb.Append("/5n72GYju4KRIYCBkyTMQESMEIyyQaEAAFBGfnZiWbDQAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property GoUp_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void GoUp_Reset()
        {
            _GoUp = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití GoUp_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _GoUp = null;
        #endregion
        #region Image FiltN
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku FiltN.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu FiltN_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property FiltN, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property FiltN_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltN.png
        /// </remarks>
        public static System.Drawing.Image FiltN_Cached
        {
            get
            {
                if (_FiltN == null) _FiltN = FiltN;
                return _FiltN;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku FiltN.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image FiltN_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití FiltN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property FiltN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltN.png
        /// </remarks>
        public static System.Drawing.Image FiltN { get { return _ImageCreateFrom(_FiltN_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru FiltN.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití FiltN_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property FiltN_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltN.png
        /// </remarks>
        public static System.Drawing.Image FiltN_FromFile { get { return _ImageCreateFrom(_FiltN_string, "FiltN.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru FiltN
        /// </summary>
        /// <returns></returns>
        private static string _FiltN_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1148);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAACy0lEQVQ4T42Sa0ySURjH32pLU7QPrVZ9a33IVUtdaWVZy1g1CTJNbd5SAofEl9QSkjCnId4viAoFzIGAqIVj5SUdlDY1");
            sb.Append("L+WNrXCzFJuaydhcaiBPvO8mY6XNs53tnO35/f7Ps3MQxGWdDQzxIRCiC/PzKoYEfLHpuUg+KxUr5wSV0jkBXzLD45bq4uJomUGBIads27zaAfFKxPBnwrrDJcVCQVWl");
            sb.Append("dGLRvAzTJvN/t/HM5VVAcGDd7r2ECfK4Fdlv9QOAwoKqWnjMKYDCIiFIpQrHXQK0lEfAzMgFLrcIRk5eBBS2eR2A8thkMya4HZ1MUaha1lDByPA4yOVqkMmUoFY3gUKh");
            sb.Append("gtKyapBWi2DqHN4JSxhMuIYP+46kpefg6LS0Jxksnv3rtwVAl91uB5NpHkbHjDAzswCrliX4jSc5YV4UFS6cv/7L/0RQDJJyj5VaXFLT+ZQr0NfU1MPi4gom6O0bBGnt");
            sb.Append("C9C1dcPalTAnXEl5ACRiAvj6BnOw9iMiqfnKxlb3V609bhHhyeXd3WNgswGMGYwg5Etg1j8Yg624/dCcUwF0OhvwIeFvfI4E7MQEFOrD+r7BcfbQpwlyEjm9icUq+Gmx");
            sb.Append("WGHetABTx05j8Jr3QRit04JQ1ABxsQyLQ3DU+fpkcupxmfxlc61M03aXmhZBJCYG9XT2L9uv3sTgVY99MKnpgIFBIzCZPGsYKSHJ9e/8cwYEcf+x99CX9eRGNhc+Dk+A");
            sb.Append("uqEdIm9R6oiEGLdNBShsR3AtWLLbHuu0Vg8qlRbE4npgMNjGqEjq7i3BdsTT3BVwKUqj0Zl6+wzAYuWv3CDFh24ZBsTDDy3m5lUput6PQPyd++9CCbG7NhS4to0mr8No");
            sb.Append("cVmZVN37wQA0etZrGp3jvqHAMbMSnflvGC0WiZRaw+dpYGfx9Zmccs9NOvDwc0gmXZPXC5XqFnqHrn+OWyDOys6t3rGR4A/mXsf8preb/gAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property FiltN_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void FiltN_Reset()
        {
            _FiltN = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití FiltN_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _FiltN = null;
        #endregion
        #region Image FiltY
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku FiltY.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu FiltY_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property FiltY, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property FiltY_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltY.png
        /// </remarks>
        public static System.Drawing.Image FiltY_Cached
        {
            get
            {
                if (_FiltY == null) _FiltY = FiltY;
                return _FiltY;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku FiltY.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image FiltY_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití FiltY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property FiltY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltY.png
        /// </remarks>
        public static System.Drawing.Image FiltY { get { return _ImageCreateFrom(_FiltY_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru FiltY.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití FiltY_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property FiltY_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// B:\Private\TraceAnalyseWF\TraceAnalyseWF\TraceAnalyseWF\pic\FiltY.png
        /// </remarks>
        public static System.Drawing.Image FiltY_FromFile { get { return _ImageCreateFrom(_FiltY_string, "FiltY.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru FiltY
        /// </summary>
        /// <returns></returns>
        private static string _FiltY_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1100);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAZdEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41Ljg3O4BdAAACp0lEQVQ4T5XS30+SURgHcLY2tdXWH9FFrrVcW7nlqgvnRUmY08xStCRx+IYXiRMRglz6gr9QURBQfHUg4KsWZf6qHFpY");
            sb.Append("4m9NmQZsNaCJGuRWqRN5wncTvXBpz/Zs52zP97Nzdg6JtK8uR0aHk8nJ5aVCyaS0VuVsVGqWMJXOLa3D3NLaJpcIrTJSqQxuVGT0Reo9+vFgtEHRelpcqZDK6jCbx7sO");
            sb.Append("Dqf3n61q0HgryqXdaLHkBoEIUUnR0OA47ISlshZ4wi+D8goFYJg2sG8CRnYhFLCLAUUrQCiSEPj09ALks/grBHA3OStTq+/d3gFmZ+ZBo8FBrdYBjneCVquHqup6aGzE");
            sb.Append("iP3U1CLRopIauB4T/53Eynt2EmGwnrI5Iv/Xb6uwU36/H5zOZfg8ZwWXaxU2N33g/fk7GGYihXDtys0/F85HpZCyH3FyK8XygRJUOiiXt4HHs0EAI+YJwFqew4BxFNY3");
            sb.Append("9gAuVwxxlHSIiLjKJ46fmEQv1XX0hXX3fQpNTMiqMZnmwOcDmLNYQSZXQ0dHP3Fn08f5APgKEIQHMdEJb8PPXAohgEx6fpt5Yp43OW2jZdDyOjmcsh9ra1vgXvkF9QFA");
            sb.Append("p38NNrsbzGNfQKFsB2oqcy0AnA0+IY2We06tefGyRW3of0hnJVIoD6KGTbPrvm2Ant4hwJpxWFh0wfiEFQoKRFvxcekZ+//OgWu0RMZ1ODxgty+BQqGGqRkb4O1vIOl2");
            sb.Append("ZiuFnBJ6KJCTIwhpxgz9dtsy6PVdoFK1AZPJs95Jop86NLw7wGaLIgwGo3PEbAEOp3TjVlxa7JHDu4OoUKb9MDwLafcfv48lp+79/aNK1dUYPjJqAQYi6GEg/LCj5oJz");
            sb.Append("SqWuy7LoAJ6gdpDLrznx34AO70XeGcfcaJlKUFRcf+wg4C+ll78LuWG/cAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property FiltY_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void FiltY_Reset()
        {
            _FiltY = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití FiltY_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _FiltY = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                if (__ImageCacheDir == null)
                    __ImageCacheDir = Noris.Tools.TraceVisualiser.Support.Steward.GetUserAppDataPath(@"IconCache\PicsC16");
                return __ImageCacheDir;
            }
        }
        private static string __ImageCacheDir;
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
